Grid computing space

ABSTRACT

A method and apparatus for using a tree-structured cluster as a library for a computing grid. In one embodiment, a request for computation is received at a cache node of the cluster. The computation requires data from an other cache node of the cluster, and not present in the cache node receiving the request. The other cache nodes of the cluster are polled for the required data. An instance of the required data stored in the other cache node of the cluster is replicated to the cache node receiving the computation request.

TECHNICAL FIELD

Embodiments of the present invention relate to cache, and more specifically to a tree-structured, clustered, transactional cache.

BACKGROUND

Caches are commonly used in computer system. A cache is a collection of data duplicating original values stored elsewhere or computed earlier, where the original data is expensive to fetch (due to slow access time) or to compute, relative to the cost of reading the cache. In other words, a cache is a temporary storage area where frequently accessed data can be stored for rapid access. Once the data is stored in the cache, future use can be made by accessing the cached copy rather than re-fetching or recomputing the original data, so that the average access time is lower.

Caches have proven to be extremely effective in many areas of computing because access patterns in typical computer applications have locality of reference (temporal and spatial locality). Temporal locality refers to data that are accessed close together in time. Spatial locality refers to data that might or might not be located physically close to each other.

In a clustered cache structure, the cluster may also provide redundant storage for security and backup purposes by replicating data to all instances in the cache cluster. As the number of nodes and cluster increase, a bottleneck may be formed when a processing component is attempting to access the data stored in the cluster. Also, replicating data to all instances may prove to impact memory and network traffic every time another instance is added to a cluster. As such, a need exists for efficiently providing data in a large cache structure.

DESCRIPTION OF THE DRAWINGS

The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which:

FIG. 1 illustrates a block diagram of replicated node caches in a cluster.

FIG. 2 illustrates a block diagram of a cluster with buddy replication of node caches in accordance with one embodiment.

FIG. 3 illustrates a block diagram of a node failure in a cluster with buddy replication enabled.

FIG. 4 illustrates a block diagram of an architecture of one embodiment of an API class structure for buddy replication.

FIG. 5 illustrates a block diagram of an exemplary computer system.

FIG. 6 illustrates a block diagram of one embodiment of a grid computing space of a cluster.

FIG. 7 illustrates a block diagram of another embodiment of a grid computing space of a cluster.

FIG. 8 illustrates a flow diagram of one embodiment of a method for grid grid computing space in a cluster.

FIG. 9 illustrates a flow diagram of another embodiment of a method for grid computing space in a cluster.

DETAILED DESCRIPTION

Described herein is a method and apparatus for using a tree-structured cluster as a library for a computing grid. In one embodiment, a request for computation is received at a cache node of the cluster. The computation requires data from an other cache node of the cluster, and not present in the cache node receiving the request. The other cache nodes of the cluster are polled for the required data. An instance of the required data stored in the other cache node of the cluster is replicated to the cache node receiving the computation request.

The cache configuration can be either local (standalone) or clustered. If in a cluster, the cache can be configured to replicate changes, or to invalidate changes. In local mode, local caches do not join a cluster and do not communicate with other caches in a cluster.

Replicated caches replicate all changes to some or all of the other cache instances in the cluster. Replication can either happen after each modification (no transactions), or at the end of a transaction (commit time).

Replication can be synchronous or asynchronous. Use of either one of the options is application dependent. Synchronous replication blocks the caller (e.g. on a put( )) until the modifications have been replicated successfully to all nodes in a cluster. Asynchronous replication performs replication in the background (the put( ) returns immediately). One example of a tree-structure cache includes JBoss® Cache which offers a replication queue, where modifications are replicated periodically (i.e. interval-based), or when the queue size exceeds a number of elements, or a combination thereof.

Asynchronous replication is faster (no caller blocking), because synchronous replication requires acknowledgments from all nodes in a cluster that they received and applied the modification successfully (round-trip time). However, when a synchronous replication returns successfully, the caller knows for sure that all modifications have been applied to all cache instances, whereas this is not be the case with asynchronous replication. With asynchronous replication, errors are simply written to a log. Even when using transactions, a transaction may succeed but replication may not succeed on all cache instances.

When using transactions, replication only occurs at the transaction boundary—i.e., when a transaction commits. This results in minimizing replication traffic since a single modification is broadcast rather than a series of individual modifications, and can be a lot more efficient than not using transactions. Another effect of this is that if a transaction were to roll back, nothing is broadcast across a cluster. Depending on whether the cluster is in asynchronous or synchronous mode, JBoss® Cache will use either a single phase or two phase commit protocol, respectively.

FIG. 1 illustrates a block diagram of replicated node caches in a cluster 100. An instance of a cache node is replicated to all cache nodes in the cluster. As such, data from cache node 102 is replicated to cache nodes 104, 106, and 108. Data from cache node 104 is replicated to cache nodes 102, 106, and 108. Data from cache node 106 is replicated to cache nodes 102, 104, and 108. Data from cache node 108 is replicated to cache nodes 102, 104, and 106.

FIG. 2 illustrates a block diagram of a cluster with buddy replication of node caches in accordance with one embodiment. Buddy replication is based on a concept where data is replicated to a finite number of nodes in a cluster rather than the entire cluster. This helps a cluster scale by not impacting network replication traffic, nor node memory usage as more nodes are added. Buddy replication may also be referred to as cluster partitioning.

Network traffic is always restricted to the number of buddy nodes configured. This may not be that great a saving as IP multicast may be used to broadcast changes, but replies (if synchronous replication is used) and subsequent wait time will increase in a linear fashion with every node added to a cluster. When the number of buddies is finite and fixed, nodes can be added to a cluster without any such impact as this replication cost is always static.

With buddy replication, memory usage for each node will be approximately (b+1) X where X is the average data size of each node and b is the number of buddies per node. This scales a lot better than total replication where each node would hold nX where n is the number of nodes in the cluster. Being a function of n, you can see that with total replication, memory usage per node increases with the number of nodes while with buddy replication, this does not happen.

It is assumed that a decent load balancer will be in use so requests are evenly spread across a cluster and sticky sessions (or equivalent for use cases other than HTTP session replication) are used so that recurring data accesses happen on fixed nodes. For illustration purposes, the number of buddies is set to one. FIG. 2 illustrates five nodes in a cluster: nodes A, B, C, D and E. Each node has its own data, and the backup data of one other node. For example, node A 202 stores its own data from node A 202 and data from node E 210. Node B 204 stores its own data from node B 204 and data from node A 202. Node C 206 stores its own data from node C 206 and data from node B 204. Node D 208 stores its own data from node D 208 and data from node C 206. Node E 210 stores its own data from node E 210 and data from node D 208. As such, data is only replicated to the buddy node, not to the entire cluster (synchronous or asynchronous replication may be used).

One of the most common use cases of Buddy Replication is when a replicated cache is used by a servlet container to store HTTP session data. One of the pre-requisites to buddy replication working well and being a real benefit is the use of session affinity, more casually known as sticky sessions in HTTP session replication speak. What this means is that if certain data is frequently accessed, it is desirable that this is always accessed on one instance rather than in a round-robin fashion as this helps the cache cluster optimize how it chooses buddies, where it stores data, and minimizes replication traffic.

FIG. 3 illustrates a block diagram of a node failure in a cluster with buddy replication enabled. If a node fails (e.g., Node A 202 is removed from the cluster) its data is still backed up on to node B 204. As nodes start looking for this data, it gravitates from node B 204 to the requesting node, which may take ownership of this data and treat it as its own. Node B 204 may also start acting as backup node for node E 210.

As requests come in to cache instances which do not have the requested data locally, nodes then ask the cluster for the data and move that data to their local state. Taking ownership of this data allows for the data most used by specific cache instances to be located closest to such cache instances. When a cache instance takes ownership of data, it forces the original owner (and any buddies) to remove this data from their in-memory state. In the above scenario of FIG. 3, this allows for the original state of A—backed up on B—to spread out evenly across the cluster as the load balancer directs requests meant for A across the cluster.

In accordance with an alternative embodiment, another implementation would include data slicing. The alternative to such a scenario where a node inherits all the backup data of a dead node is for the backup node to slice the data evenly and distribute it across the remaining cluster nodes rather than taking ownership of the data.

Behavior is precisely the same as when dealing with just one buddy. The first instance to provide a valid response to a data gravitation request is the one that is used as the source of data. When a buddy node dies, the Data Owner detects this, and nominates more buddies to meet its configured requirement. State transfers may be initiated to these buddies so backups are preserved.

One way to implement Buddy replication is by enhancing the BaseRPCInterceptor. This way existing replication semantics do not change in any of the subclasses of the BaseRPCInterceptor—the only thing that changes is the BaseRPCInterceptor.replicateCall( ) method, which based on configuration, replicates to the entire group or to specific nodes. The BaseRPCInterceptor will maintain a reference to a BuddyManager (if configured), which will use a BuddyLocator to maintain a list of buddies.

Configuring Buddy Replication

A new configuration element—BuddyReplicationConfig—may be used. The element will take an XML config element, to maintain consistency with the way eviction policies and cache loaders are configured.

 <attribute name=“BuddyReplicationConfig”>   <config>    <buddyReplicationEnabled>true</buddyReplicationEnabled> <buddyLocatorClass>org.JBoss.cache.cluster.- NextMemberBuddyLocator</buddyLocator Class> <buddyCommunicationTimeout>15000</buddyCommunicationTimeout>    <buddyLocatorProperties>numBuddies = 3</buddyLocatorProperties> <dataGravitationRemoveOnFind>true</dataGravitationRemoveOnFind> <dataGravitationSearchBackupTrees>true- </dataGravitationSearchBackupTrees>    <autoDataGravitation>false</autoDataGravitation>    <buddyPoolName>groupOne</buddyPoolName>   </config>  </attribute>

If this configuration element is left empty or is ignored altogether, the BaseRPCInterceptor will revert to replicating to the entire cluster. The buddyLocatorClass element is optional, and defaults to NextMemberBuddyLocator. The configuration element is provided for future expandability/customization.

The buddyPoolName element is optional, and if specified, creates a logical subgroup and only picks buddies who share the same buddy pool name. This helps you (the sys admin) assert some control over how buddy selection takes place. For example, you may have 3 power sources in your HA cluster and you may want to ensure that buddies picked are never on the same power source. If not specified, this defaults to an internal constant name which then treats the entire cluster as a single buddy pool. The buddyCommunicationTimeout property is optional and defaults to 10000. This is the timeout used for RPC calls to remote caches when setting up buddy groups. The only mandatory property here is buddyReplicationEnabled, which is used to enable/disable buddy replication.

In its simplest form, Buddy Replication could be enabled with:

<attribute name=“BuddyReplicationConfig”>  <config>   <buddyReplicationEnabled>true</buddyReplicationEnabled>  </config> </attribute>

Gravitation of Data

Data gravitation is implemented as an Interceptor, that sits after the CacheLoaderInterceptor. If data gravitation is enabled for the invocation (more on this in a bit) the interceptor tests if the node exists in the cache (after potentially loading/activating it). If not, it will broadcast a data gravitation call for this node and all subnodes, and proceed to take ownership of it. Enabling data gravitation for a particular invocation can be done in two ways. Enabling autoDataGravitation (false by default) or by setting an Option (see the Options API).

Upon startup, the BuddyManager will use the configured BuddyLocator implementation to help it locate and select its buddy or buddies. Note that the BuddyLocator is only invoked when a change in cluster membership is detected.

To ensure that backup data is maintained separate from primary data on each node, each node will use an internal subtree for each buddy group it participates in, and will contain the name of the Buddy Group it is backing up for. This Buddy Group name is simply a String representation of JGroups Address of the Data Owner of that Buddy Group.

-   -   /_buddy_backup_/server01:7890/     -   /_buddy_backup_/server02:7890/

Also, users would have to ensure that any eviction policies set up are not applied to the /_buddy_backup_subtree.

FIG. 4 illustrates a block diagram of an architecture of one embodiment of an API class structure for buddy replication. TreeCache class 404 is enhanced to define three new internal methods:

public void_remoteAssignToBuddyGroup(BuddyGroup group, Map state)

public void_remoteRemoveFromBuddyGroup(String groupName)

public void_remoteAnnounceBuddyPoolName(IpAddress address, String buddyPoolName)

The first two methods are called on remote caches (buddies) by Data Owners to add them or remove them from a BuddyGroup 414. The last one is called on all remote caches (multicast) every time a view change is detected, so each cache has an accurate map of buddy pools. This method is only called if a buddy pool is configured.

BuddyManager class 402 controls the group for which a TreeCache 404 instance is a data owner as well as all other groups for which the TreeCache 404 instance participates as a buddy. If buddy replication is configured, an instance of BuddyManager 402 is created and referenced by the TreeCache 404. BuddyManager 402 maintains a reference to a single BuddyGroup 414 for which the TreeCache 404 instance is Data Owner, as well as a collection of BuddyGroups for which the TreeCache is a buddy. BuddyManager class 402 creates a BuddyGroupMembershipMonitor, which implements TreeCacheListener, and registers this monitor to react to changes in the underlying group structure. BuddyManager class 402 also maintains a reference to an instance of BuddyLocator, used to build a BuddyGroup 414.

BuddyGroup class 414 maintains a List of Addresses which represent the buddy nodes for the group. The class also maintains an Address reference of the Data Owner as well as a String representing the group name (dataOwnerAddress.toString( )). The class also creates an Fqn which is a backup root for this group, typically being the value of Fqn.fromString(“/_buddy_backup_/”+groupName). This is used by BuddyManager.transformFqns(MethodCall call). This class will be passed over the wire as an argument to RPC calls.

For BaseRPCInterceptor class 406, when replicateCall( ) is called on this interceptor, it will only replicate to BuddyManager.getBuddyAddresses( ) rather than the entire cluster, if a BuddyManager 402 is available. In addition, it will transform the method call it tries to replicate by using BuddyManager.transformFqns(MethodCall call) before replicating anything.

BuddyLocator class 410 defines two methods: (1) public void init(Properties p) which is used to pass in locator specific properties to the implementation on startup; and (2) public List getBuddies(List groupMembers) which selects one or more buddies from a list of group members. End users may extend buddy replication functionality by providing their own buddy locating algorithms.

NextMemberBuddyLocator class 412 picks a buddy based on who is ‘next in line’. Will take in an optional configuration property numBuddies (defaults to 1) and will attempt to select as many buddies when getBuddies( ) is called. This also takes in another optional configuration property ignoreColocatedBuddies, defaulting to true, which ensures that nodes on the same physical machine are not selected as buddies.

Colocated nodes are detected by comparing their InetAddress properties. We can also detect all the InetAddress instances available on a single host by consulting the enumeration returned by java.net.Networklnterface.getNetworklnterfaces( ). This will conclusively tell us whether 2 cluster members are on the same host or not.

Only buddies who share the same pool name are considered if buddyPoolName is configured. In the end, buddy pools and ignoring colocated hosts are just hints—if no buddies can be found to meet these constraints, buddies that do not meet these constraints will be tried.

Transferring State

When a buddy is nominated to participate in a BuddyGroup (by having its _remoteAssignToGroup( ) method called), the Data Owner's state will be pushed as an argument of the call. State is then stored under /_buddy_backup_/server01:7890/. Note that this takes place in a separate thread, so that _remoteAssignToGroup( ) can return immediately.

One major change in the state transfer code will be to exclude anything under /_buddy_backup_when marshalling the tree. Also, when invoked by BuddyManager.assignToGroup( ), the state transfer process should be able to store state received in the relevant backup subtree. This may mean overloading the local state transfer method with a root under which state would be stored, defaulting to TreeCache.getRoot( ). Note that this does not affect remote state transfer methods so there should be no issue regarding backward compatibility.

Also, with buddy replication, initial state transfers should always be disable as nodes will pull down state relevant to their BuddyGroups as they are assigned to such groups.

Computer System

FIG. 5 illustrates a diagrammatic representation of a machine in the exemplary form of a computer system 500 within which a set of instructions, for causing the machine to perform any one or more of the methodologies discussed herein, may be executed. In alternative embodiments, the machine may be connected (e.g., networked) to other machines in a LAN, an intranet, an extranet, or the Internet. The machine may operate in the capacity of a server or a client machine in client-server network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a Personal Digital Assistant (PDA), a cellular telephone, a web appliance, a server, a network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term “machine” shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.

The exemplary computer system 500 includes a processing device 502, a main memory 504 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM), a static memory 506 (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage device 518, which communicate with each other via a bus 530.

Processing device 502 represents one or more general-purpose processing devices such as a microprocessor, central processing unit, or the like. More particularly, the processing device may be complex instruction set computing (CISC) microprocessor, reduced instruction set computing (RISC) microprocessor, very long instruction word (VLIW) microprocessor, or processor implementing other instruction sets, or processors implementing a combination of instruction sets. Processing device 502 may also be one or more special-purpose processing devices such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), network processor, or the like. The processing device 502 is configured to execute the processing logic 526 for performing the operations and steps discussed herein.

The computer system 500 may further include a network interface device 508. The computer system 500 also may include a video display unit 510 (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)), an alphanumeric input device 512 (e.g., a keyboard), a cursor control device 514 (e.g., a mouse), and a signal generation device 516 (e.g., a speaker).

The data storage device 518 may include a machine-accessible storage medium 530 on which is stored one or more sets of instructions (e.g., software 522) embodying any one or more of the methodologies or functions described herein. The software 522 may also reside, completely or at least partially, within the main memory 504 and/or within the processing device 502 during execution thereof by the computer system 500, the main memory 504 and the processing device 502 also constituting machine-accessible storage media. The software 522 may further be transmitted or received over a network 520 via the network interface device 508.

The machine-accessible storage medium 530 may also be used to store grid computing space configurations 524. Grid computing space configurations 524 may also be stored in other sections of computer system 500, such as static memory 506.

While the machine-accessible storage medium 530 is shown in an exemplary embodiment to be a single medium, the term “machine-accessible storage medium” should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, and/or associated caches and servers) that store the one more sets of instructions. The term “machine-accessible storage medium” shall also be taken to include any medium that is capable of storing, encoding or carrying a set of instructions for execution by the machine and that cause the machine to perform any one or more of the methodologies of the present invention. The term “machine-accessible storage medium” shall accordingly be taken to include, but not be limited to, solid-state memories, optical and magnetic media, and carrier wave signals.

FIG. 6 illustrates a block diagram of one embodiment of a grid computing space of a cluster. The tree-structured cache cluster 602 may includes nodes 602, 604, 606, 608, and 610. For example, node 602 may be processing a computation that may require data C from node 606. In this example, node 602 polls the other nodes in the cluster for data C. Node 606 notifies that it has data C. Once node 602 determines that node 606 has the needed data, data C gravitates from node 606 to node 602. In one embodiment, the gravitation of data may include replicating the data from one node to another node. Such gravitation of data from node to node in a tree-structured cache cluster may prove to be more efficient than having a processing component access each node individually.

FIG. 7 illustrates a block diagram of another embodiment of a grid computing space of a cluster. After data X has gravitated to the processing node 702, node 702 sends a signal to all the other nodes 704, 706, 708, and 710 in the cluster 700 to determine whether the data X is also stored in any other nodes of the cluster 700. This is represented by arrows labeled (1) in FIG. 7.

In this example of FIG. 7, nodes 704 and 706 also store a copy of data X. As such, in response to the query of node 702, nodes 704 and 706 notify node 702 that data X also exist on nodes 704, 706. This is represented by arrows labeled (2) in FIG. 7.

If data X is not needed anymore in node 702, node 702 may optionally delete data X from node 702 and notify such action to the nodes having a copy of data X. This is represented by arrows labeled (1) in FIG. 7. This is to assure that at least one node in the cluster 700 still has data X.

FIG. 8 illustrates a flow diagram of one embodiment of a method for grid computing space in a cluster. At 802, a request for computation is received at a cache node of the cluster. The computation may require data from another cache node of the cluster. At 804, the processing node polls the other nodes in the cluster for the required data. At 806, once the location of the needed data is determined, the required data gravitates from one node to the processing node. In one embodiment, an instance of the required data stored in the other cache node of the cluster is replicated to the cache node receiving the computation request.

FIG. 9 illustrates a flow diagram of another embodiment of a method for grid computing space in a cluster. At 902, the processing node may poll again for data X in the other nodes in the cluster. At 904, processing node determines whether data X is still needed. If so, at 906, the processing node retains data X. If data X is not needed anymore in the processing node, the processing node notifies the other nodes in the cluster that it is about to delete data X at 908. At 910, the processing node deletes data X.

As discussed above, the cluster includes several cache nodes, each cache node selecting one (or more) other cache node as a backup. The cache nodes may be located on different physical hosts or on different physical racks.

In accordance with another embodiment, one or more pools of cache nodes may be formed in the cluster, where an instance of a cache node from a pool is replicated to one cache node in the same pool. The cache nodes from a pool are located on different physical racks.

In one embodiment, the cache node is used by a servlet container to store HTTP session data, where the HTTP session data is accessed on one instance of the cache node on which the HTTP session data resides.

In the above description, numerous details are set forth. It will be apparent, however, to one skilled in the art, that the present invention may be practiced without these specific details. In some instances, well-known structures and devices are shown in block diagram form, rather than in detail, in order to avoid obscuring the present invention.

Some portions of the detailed descriptions are presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of steps leading to a desired result. The steps are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.

It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the following discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices.

The present invention also relates to apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMs, and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, or any type of media suitable for storing electronic instructions, and each coupled to a computer system bus.

Thus, a method and apparatus for obtaining data from a cache node in a tree-based cluster have been described. It is to be understood that the above description is intended to be illustrative, and not restrictive. Many other embodiments will be apparent to those of skill in the art upon reading and understanding the above description. The scope of the invention should, therefore, be determined with reference to the appended claim, along with the full scope of equivalents to which such claims are entitled. 

1. A computer-implemented method for using a tree-structured cluster as a library for a computing grid, the method comprising: receiving a request for computation at a cache node of the cluster, the computation requiring data from an other cache node of the cluster; polling the other cache nodes of the cluster for the required data; and replicating an instance of the required data stored in the other cache node of the cluster to the cache node receiving the computation request.
 2. The method of claim 1 further comprising: processing the request for computation with the cache node receiving the computation request; polling the other cache nodes of the cluster for data stored in the cache node receiving the computation request; determining whether a need still exists for the data stored in the cache node receiving the computation request after the computation; and deleting the data stored in the cache node receiving the computation request upon determining that no need exists for the data stored in the cache node receiving the computation request and that the data is also stored in at least one other cache node of the cluster.
 3. The method of claim 1 wherein receiving the request for computation further comprises: receiving a query for data in the cache node of the cluster; determining whether the data is stored in the queried cache node; inquiring the other cache nodes in the cluster for the data; and replicating an instance of the data from a cache node storing the data to the queried cache node.
 4. The method of claim 3 wherein inquiring other cache nodes in the cluster for the data further comprises: inquiring a data backup of each cache node in the cluster.
 5. The method of claim 3 further comprising: deleting the instance of the data from the cache node storing the data after the instance of the data has been copied to the queried cache node.
 6. The method of claim 3 further comprising: automatically inquiring the other cache nodes upon determining that the queried data is not stored in the queried cache node.
 7. The method of claim 3 further comprising: inquiring the other cache nodes based on a per-invocation basis.
 8. The method of claim 3 wherein the cluster comprises a plurality of cache nodes, each cache node selecting one other cache node as a backup.
 9. The method of claim 3 wherein the cache nodes are located on different physical hosts.
 10. The method of claim 3 wherein the cache nodes are located on different physical racks.
 11. The method of claim 3 wherein one or more pools of cache nodes are formed in the cluster, wherein an instance of a cache node from a pool is replicated to one cache node in the same pool.
 12. The method of claim 11 wherein the cache nodes from a pool are located on different physical racks.
 13. An apparatus comprising: a server to receive a request for computation at a cache node of a tree-structured cluster, the computation requiring data from an other cache node of the cluster, to poll the other cache nodes of the cluster for the required data, and to replicate an instance of the required data stored in the other cache node of the cluster to the cache node receiving the computation request.
 14. The apparatus of claim 13 wherein the server is to further process the request for computation with the cache node receiving the computation request, to poll the other cache nodes of the cluster for data stored in the cache node receiving the computation request, to determine whether a need still exists for the data stored in the cache node receiving the computation request after the computation, and to delete the data stored in the cache node receiving the computation request upon determining that no need exists for the data stored in the cache node receiving the computation request and that the data is also stored in at least one other cache node of the cluster.
 15. The apparatus of claim 13 wherein the server is to receive a query for data in the cache node of the cluster, to determine whether the data is stored in the queried cache node, to inquire the other cache nodes in the cluster for the data, and replicate an instance of the data from a cache node storing the data to the queried cache node.
 16. The apparatus of claim 15 wherein the server is to further inquire a data backup of each cache node in the cluster.
 17. The apparatus of claim 15 wherein the server is to further delete the instance of the data from the cache node storing the data after the instance of the data has been copied to the queried cache node.
 18. The apparatus of claim 15 wherein the server is to further automatically inquiring the other cache nodes upon determining that the queried data is not stored in the queried cache node.
 19. The apparatus of claim 15 wherein the server is to further inquire the other cache nodes based on a per-invocation basis.
 20. The apparatus of claim 15 wherein the cluster comprises a plurality of cache nodes, each cache node selecting one other cache node as a backup.
 21. The apparatus of claim 15 wherein the cache nodes are located on different physical hosts.
 22. The apparatus of claim 15 wherein the cache nodes are located on different physical racks.
 23. The apparatus of claim 15 wherein one or more pools of cache nodes are formed in the cluster, wherein an instance of a cache node from a pool is replicated to one cache node in the same pool.
 24. The apparatus of claim 23 wherein the cache nodes from a pool are located on different physical racks.
 25. An article of manufacture comprising: a machine-accessible storage medium including data that, when accessed by a machine, cause the machine to perform a method for using a tree-structured cluster as a library for a computing grid, the method comprising: receiving a request for computation at a cache node of the cluster, the computation requiring data from an other cache node of the cluster; polling the other cache nodes of the cluster for the required data; and replicating an instance of the required data stored in the other cache node of the cluster to the cache node receiving the computation request.
 26. The article of manufacture of claim 25 wherein the method further comprises: processing the request for computation with the cache node receiving the computation request; polling the other cache nodes of the cluster for data stored in the cache node receiving the computation request; determining whether a need still exists for the data stored in the cache node receiving the computation request after the computation; and deleting the data stored in the cache node receiving the computation request upon determining that no need exists for the data stored in the cache node receiving the computation request and that the data is also stored in at least one other cache node of the cluster.
 27. The article of manufacture of claim 25 wherein the method further comprises: receiving a query for data in the cache node of the tree-structured cluster; determining whether the data is stored in the queried cache node; inquiring other cache nodes in the cluster for the data; and replicating an instance of the data from a cache node storing the data to the queried cache node.
 28. The article of manufacture of claim 25 wherein inquiring other cache nodes in the cluster for the data further comprises: inquiring a data backup of each cache node in the cluster.
 29. The article of manufacture of claim 25 wherein the method further comprises: deleting the instance of the data from the cache node storing the data after the instance of the data has been copied to the queried cache node.
 30. The article of manufacture of claim 25 wherein the method further comprises: automatically inquiring the other cache nodes upon determining that the queried data is not stored in the queried cache node.
 31. The article of manufacture of claim 25 wherein the method further comprises: inquiring the other cache nodes based on a per-invocation basis.
 32. The article of manufacture of claim 25 wherein the cluster comprises a plurality of cache nodes, each cache node selecting one other cache node as a backup.
 33. The article of manufacture of claim 25 wherein the cache nodes are located on different physical hosts.
 34. The article of manufacture of claim 25 wherein the cache nodes are located on different physical racks.
 35. The article of manufacture of claim 25 wherein one or more pools of cache nodes are formed in the cluster, wherein an instance of a cache node from a pool is replicated to one cache node in the same pool.
 36. The article of manufacture of claim 35 wherein the cache nodes from a pool are located on different physical racks. 